Machine learning is about creating models from data: for that reason, we'll start by discussing how data can be represented in order to be understood by the computer. Along with this, we'll build on our matplotlib examples from the previous section and show some examples of how to visualize data.
By the end of this section you should:
Data in scikit-learn, with very few exceptions, is assumed to be stored as a
two-dimensional array, of size [n_samples, n_features]
.
Most machine learning algorithms implemented in scikit-learn expect data to be stored in a
two-dimensional array or matrix. The arrays can be
either numpy
arrays, or in some cases scipy.sparse
matrices.
The size of the array is expected to be [n_samples, n_features]
The number of features must be fixed in advance. However it can be very high dimensional
(e.g. millions of features) with most of them being zeros for a given sample. This is a case
where scipy.sparse
matrices can be useful, in that they are
much more memory-efficient than numpy arrays.
As an example of a simple dataset, we're going to take a look at the iris data stored by scikit-learn. The data consists of measurements of three different species of irises. There are three species of iris in the dataset, which we can picture here:
In [ ]:
from IPython.core.display import Image, display
display(Image(filename='figures/iris_setosa.jpg'))
print("Iris Setosa\n")
display(Image(filename='figures/iris_versicolor.jpg'))
print("Iris Versicolor\n")
display(Image(filename='figures/iris_virginica.jpg'))
print("Iris Virginica")
If we want to design an algorithm to recognize iris species, what might the data be?
Remember: we need a 2D array of size [n_samples x n_features]
.
What would the n_samples
refer to?
What might the n_features
refer to?
Remember that there must be a fixed number of features for each sample, and feature
number i
must be a similar kind of quantity for each sample.
Scikit-learn has a very straightforward set of data on these iris species. The data consist of the following:
Features in the Iris dataset:
Target classes to predict:
scikit-learn
embeds a copy of the iris CSV file along with a helper function to load it into numpy arrays:
In [ ]:
from sklearn.datasets import load_iris
iris = load_iris()
The resulting dataset is a Bunch
object: you can see what's available using
the method keys()
:
In [ ]:
iris.keys()
The features of each sample flower are stored in the data
attribute of the dataset:
In [ ]:
n_samples, n_features = iris.data.shape
print(n_samples)
print(n_features)
print(iris.data[0])
The information about the class of each sample is stored in the target
attribute of the dataset:
In [ ]:
print(iris.data.shape)
print(iris.target.shape)
In [ ]:
print(iris.target)
The names of the classes are stored in the last attribute, namely target_names
:
In [ ]:
print(iris.target_names)
This data is four dimensional, but we can visualize two of the dimensions at a time using a simple scatter-plot. Again, we'll start by enabling matplotlib inline mode:
In [ ]:
%matplotlib inline
from matplotlib import pyplot as plt
In [ ]:
x_index = 0
y_index = 1
# this formatter will label the colorbar with the correct target names
formatter = plt.FuncFormatter(lambda i, *args: iris.target_names[int(i)])
plt.scatter(iris.data[:, x_index], iris.data[:, y_index], c=iris.target)
plt.colorbar(ticks=[0, 1, 2], format=formatter)
plt.xlabel(iris.feature_names[x_index])
plt.ylabel(iris.feature_names[y_index])
Change x_index
and y_index
in the above script
and find a combination of two parameters
which maximally separate the three classes.
This exercise is a preview of dimensionality reduction, which we'll see later.
Scikit-learn makes available a host of datasets for testing learning algorithms. They come in three flavors:
sklearn.datasets.load_*
sklearn.datasets.fetch_*
sklearn.datasets.make_*
You can explore the available dataset loaders, fetchers, and generators using IPython's
tab-completion functionality. After importing the datasets
submodule from sklearn
,
type
datasets.load_<TAB>
or
datasets.fetch_<TAB>
or
datasets.make_<TAB>
to see a list of available functions.
In [ ]:
from sklearn import datasets
The data downloaded using the fetch_
scripts are stored locally,
within a subdirectory of your home directory.
You can use the following to determine where it is:
In [ ]:
from sklearn.datasets import get_data_home
get_data_home()
In [ ]:
!ls $HOME/scikit_learn_data/
Be warned: many of these datasets are quite large, and can take a long time to download! (especially on Conference wifi).
If you start a download within the IPython notebook and you want to kill it, you can use ipython's "kernel interrupt" feature, available in the menu.
Now we'll take a look at another dataset, one where we have to put a bit more thought into how to represent the data. We can explore the data in a similar manner as above:
In [ ]:
from sklearn.datasets import load_digits
digits = load_digits()
In [ ]:
digits.keys()
In [ ]:
n_samples, n_features = digits.data.shape
print(n_samples, n_features)
In [ ]:
print(digits.data[0])
print(digits.target)
The target here is just the digit represented by the data. The data is an array of length 64... but what does this data mean?
There's a clue in the fact that we have two versions of the data array:
data
and images
. Let's take a look at them:
In [ ]:
print(digits.data.shape)
print(digits.images.shape)
We can see that they're related by a simple reshaping:
In [ ]:
import numpy as np # numpy!
print(np.all(digits.images.reshape((1797, 64)) == digits.data))
Aside... numpy and memory efficiency:
You might wonder whether duplicating the data is a problem. In this case, the memory overhead is very small. Even though the arrays are different shapes, they point to the same memory block, which we can see by doing a bit of digging into the guts of numpy:
In [ ]:
print(digits.data.__array_interface__['data'])
print(digits.images.__array_interface__['data'])
The long integer here is a memory address: the fact that the two are the same tells us that the two arrays are looking at the same data.
Let's visualize the data. It's little bit more involved than the simple scatter-plot we used above, but we can do it rather quickly.
In [ ]:
# set up the figure
fig = plt.figure(figsize=(6, 6)) # figure size in inches
fig.subplots_adjust(left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)
# plot the digits: each image is 8x8 pixels
for i in range(64):
ax = fig.add_subplot(8, 8, i + 1, xticks=[], yticks=[])
ax.imshow(digits.images[i], cmap=plt.cm.binary, interpolation='nearest')
# label the image with the target value
ax.text(0, 7, str(digits.target[i]))
We see now what the features mean. Each feature is a real-valued quantity representing the darkness of a pixel in an 8x8 image of a hand-written digit.
Even though each sample has data that is inherently two-dimensional, the data matrix flattens this 2D data into a single vector, which can be contained in one row of the data matrix.
Here we'll take a moment for you to explore the datasets yourself. Later on we'll be using the Olivetti faces dataset. Take a moment to fetch the data (about 1.4MB), and visualize the faces. You can copy the code used to visualize the digits above, and modify it for this data.
In [ ]:
from sklearn.datasets import fetch_olivetti_faces
In [ ]:
# fetch the faces data
In [ ]:
# Use a script like above to plot the faces image data.
# hint: plt.cm.bone is a good colormap for this data
In [ ]:
%load solutions/02A_faces_plot.py